const db = wx.cloud.database()
const questionsCollection = db.collection('timu')
const saveCollection = db.collection('save') // 新增保存题目信息的集合

Page({
  data: {
    input: '',  // 存放用户输入的数据
    questions: [], // 从数据库获取的所有题目
    questionId: 0, // 当前题目索引
    currentQuestion: {}, // 当前展示的题目
    right: 0,
    wrong: 0,
    currentQuestionTime: 0, // 当前题目花费的时间（以秒为单位）
    totalQuestionTime: 0, // 答题总时间
    answered: [], // 记录每个题目的答题状态
    startTime: 0, // 记录答题开始时间
    timer: null, // 定时器标识
    showAnswer: false, // 是否显示正确答案和解析
    correctCount: 0 // 新增：记录答对的题目数量
  },

  onLoad: function () {
    this.fetchQuestions()
    this.data.startTime = Date.now()
    this.startTimer()
  },

  // 从数据库获取题目
  fetchQuestions: function () {
    questionsCollection.where({
      type: '填空题'
    }).get({
      success: res => {
        let questions = res.data;
        // 对题目数组进行随机排序
        questions.sort(() => Math.random() - 0.5);
        // 选择前10道题目
        questions = questions.slice(0, 10);
        this.setData({
          questions: questions,
          answered: new Array(questions.length).fill(false),
          correctCount: 0 // 初始化答对题目数量
        })
        this.setQuestion()
      },
      fail: err => {
        console.error('获取题目失败', err)
      }
    })
  },

  // 设置题目
  setQuestion: function () {
    if (this.data.questionId < this.data.questions.length) {
      this.setData({
        currentQuestion: this.data.questions[this.data.questionId],
        showAnswer: false // 重置显示正确答案和解析的状态
      }, () => {
        // 确保在 setData 完成后再调用 resetinput
        this.resetinput();
      });
    } else {
      // 所有题目已答完，可进行后续处理，如显示答题结果等
      console.log('所有题目已答完')
      this.goToFinishPage()
    }
  },

  // 接收用户输入的数据
  input(e) {
    this.setData({
      input: e.detail.value
    })
  },

  // 判断对错并换一道题
  answer() {
    if (!this.data.input) {
      wx.showToast({
        icon: 'none',
        title: '请填写答案',
      });
      return;
    }

    let isCorrect = this.data.input === this.data.currentQuestion.answer[0]
    this.setData({
      [isCorrect ? 'right' : 'wrong']: this.data[isCorrect ? 'right' : 'wrong'] + 1,
      answered: this.data.answered.map((v, index) => index === this.data.questionId ? true : v),
      showAnswer: true // 显示正确答案和解析
    })

    wx.showToast({
      title: isCorrect ? '恭喜您答对啦~' : '很遗憾您答错了~',
      icon: isCorrect ? 'success' : 'error'
    })

    if (isCorrect) {
      this.setData({
        correctCount: this.data.correctCount + 1 // 更新答对题目数量
      })
    } else {
      this.saveCuotiToDatabase(this.data.currentQuestion, this.data.input);
    }

    setTimeout(() => {
      this.setData({
        questionId: this.data.questionId + 1
      })
      this.setQuestion()
    }, 3000)
  },

  // 重置输入框状态
  resetinput: function () {
    this.setData({
      input: ''
    }, () => {
      // console.log('Input 已重置为:', this.data.input); // 调试信息
    });
  },

  // 收藏题目
  collectQuestion() {
    const questionData = {
      questionId: this.data.questionId,
      title: this.data.currentQuestion.title,
      userAnswer: this.data.input,
      correctAnswer: this.data.currentQuestion.answer[0],
      type: this.data.currentQuestion.type,
      explain: this.data.currentQuestion.explain,
      timestamp: new Date().toISOString() // 添加时间戳以便记录收藏时间
    };

    // 获取openid
    const openid = wx.getStorageSync('openid');
    const db = wx.cloud.database();
    const usersCollection = db.collection('users');

    // 查询用户记录
    usersCollection.where({
      openid: openid
    }).get().then(res => {
      if (res.data.length > 0) {
        let save = res.data[0].save || [];
        let existingQuestion = save.find(item => item.title === questionData.title);
        if (existingQuestion) {
          // 如果存在相同标题的记录，可以选择更新或提示用户
          console.log('已存在相同标题的记录', existingQuestion);
          wx.showToast({
            title: '此题目已收藏',
            icon: 'none'
          });
        } else {
          // 如果不存在相同标题的记录，则插入新记录
          save.push(questionData);
          usersCollection.doc(res.data[0]._id).update({
            data: {
              save: save
            },
            success: res => {
              console.log('题目已成功保存到用户记录', res);
              wx.showToast({
                title: '收藏成功',
                icon: 'success'
              });
            },
            fail: err => {
              console.error('保存题目失败', err);
              wx.showToast({
                title: '收藏失败',
                icon: 'none'
              });
            }
          });
        }
      } else {
        console.error('用户记录不存在');
        wx.showToast({
          title: '用户记录不存在',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('查询用户记录失败', err);
    });
  },

  // 启动定时器，开始记录答题时间
  startTimer() {
    this.data.timer = setInterval(() => {
      let currentTime = Math.floor((Date.now() - this.data.startTime) / 1000);
      this.setData({
        currentQuestionTime: currentTime
      });
    }, 1000);
  },

  // 跳转到答题结束页面
  goToFinishPage() {
    if (this.data.timer) {
      clearInterval(this.data.timer);
      this.setData({
        totalQuestionTime: this.data.currentQuestionTime
      })
      wx.redirectTo({
        url: `/pages/answer-finish/answer-finish?totalTime=${this.data.totalQuestionTime}&correctCount=${this.data.correctCount}`, // 传递答对题目数量
      });
    }
  },

  // 上一题
  prevQuestion() {
    if (this.data.questionId > 0) {
      this.setData({
        questionId: this.data.questionId - 1,
        showAnswer: false // 切换题目时隐藏正确答案
      });
    }
  },

  // 下一题
  nextQuestion() {
    if (this.data.questionId < this.data.questions.length - 1) {
      this.setData({
        questionId: this.data.questionId + 1,
        showAnswer: false // 切换题目时隐藏正确答案
      });
    }
  },

  // 保存错题到数据库
  saveCuotiToDatabase(questionData, userAnswer) {
    const openid = wx.getStorageSync('openid');
    const db = wx.cloud.database();
    const usersCollection = db.collection('users');

    usersCollection.where({
      openid: openid
    }).get().then(res => {
      if (res.data.length > 0) {
        let cuoti = res.data[0].cuoti || [];
        let existingQuestion = cuoti.find(item => item.title === questionData.title);
        if (existingQuestion) {
          console.log('已存在相同标题的记录', existingQuestion);
          wx.showToast({
            title: '此题目已记录为错题',
            icon: 'none'
          });
        } else {
          cuoti.push({
            questionId: questionData._id,
            title: questionData.title,
            userAnswer: userAnswer,
            correctAnswer: questionData.answer[0],
            type: questionData.type,
            explain: questionData.explain,
            timestamp: new Date().toISOString()
          });
          usersCollection.doc(res.data[0]._id).update({
            data: {
              cuoti: cuoti
            },
            success: res => {
              console.log('错题已成功保存到用户记录', res);
              wx.showToast({
                title: '错题记录成功',
                icon: 'success'
              });
            },
            fail: err => {
              console.error('保存错题失败', err);
              wx.showToast({
                title: '错题记录失败',
                icon: 'none'
              });
            }
          });
        }
      } else {
        console.error('用户记录不存在');
        wx.showToast({
          title: '用户记录不存在',
          icon: 'none'
        });
      }
    }).catch(err => {
      console.error('查询用户记录失败', err);
    });
  }
})